// Output created by jacc on Fri Sep 19 00:22:58 CEST 2014

package it.unicam.fishpass.prism.parser;

import java.util.*;
import java.io.*;

class FishPassParser implements FishPassParserTokens {
	private int yyss = 100;
	private int yytok;
	private int yysp = 0;
	private int[] yyst;
	protected int yyerrno = (-1);
	private Object[] yysv;
	private Object yyrv;

	public boolean parse() {
		int yyn = 0;
		yysp = 0;
		yyst = new int[yyss];
		yysv = new Object[yyss];
		yytok = (lexer.token);
		loop: for (;;) {
			switch (yyn) {
			case 0:
				yyst[yysp] = 0;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 145:
				switch (yytok) {
				case automaton:
					yyn = 2;
					continue;
				}
				yyn = 293;
				continue;

			case 1:
				yyst[yysp] = 1;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 146:
				switch (yytok) {
				case ENDINPUT:
					yyn = 290;
					continue;
				}
				yyn = 293;
				continue;

			case 2:
				yyst[yysp] = 2;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 147:
				switch (yytok) {
				case maxtime:
					yyn = 4;
					continue;
				}
				yyn = 293;
				continue;

			case 3:
				yyst[yysp] = 3;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 148:
				switch (yytok) {
				case LSBRACK:
					yyn = 7;
					continue;
				}
				yyn = 293;
				continue;

			case 4:
				yyst[yysp] = 4;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 149:
				switch (yytok) {
				case EQ:
					yyn = 8;
					continue;
				}
				yyn = 293;
				continue;

			case 5:
				yyst[yysp] = 5;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 150:
				switch (yytok) {
				case ARC:
					yyn = 10;
					continue;
				case URGARC:
					yyn = 11;
					continue;
				}
				yyn = 293;
				continue;

			case 6:
				yyst[yysp] = 6;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 151:
				switch (yytok) {
				case endautomaton:
					yyn = 12;
					continue;
				}
				yyn = 293;
				continue;

			case 7:
				yyst[yysp] = 7;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 152:
				switch (yytok) {
				case VAR:
					yyn = 13;
					continue;
				}
				yyn = 293;
				continue;

			case 8:
				yyst[yysp] = 8;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 153:
				switch (yytok) {
				case NUM:
					yyn = 14;
					continue;
				}
				yyn = 293;
				continue;

			case 9:
				yyst[yysp] = 9;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 154:
				yyn = yys9();
				continue;

			case 10:
				yyst[yysp] = 10;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 155:
				yyn = yys10();
				continue;

			case 11:
				yyst[yysp] = 11;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 156:
				yyn = yys11();
				continue;

			case 12:
				yyst[yysp] = 12;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 157:
				switch (yytok) {
				case ENDINPUT:
					yyn = yyr1();
					continue;
				}
				yyn = 293;
				continue;

			case 13:
				yyst[yysp] = 13;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 158:
				switch (yytok) {
				case RSBRACK:
					yyn = 31;
					continue;
				case SEPARATOR:
					yyn = 32;
					continue;
				}
				yyn = 293;
				continue;

			case 14:
				yyst[yysp] = 14;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 159:
				switch (yytok) {
				case NODE_DEC:
					yyn = 33;
					continue;
				}
				yyn = 293;
				continue;

			case 15:
				yyst[yysp] = 15;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 160:
				yyn = yys15();
				continue;

			case 16:
				yyst[yysp] = 16;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 161:
				switch (yytok) {
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr43();
					continue;
				}
				yyn = 293;
				continue;

			case 17:
				yyst[yysp] = 17;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 162:
				switch (yytok) {
				case RSBRACK:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr28();
					continue;
				}
				yyn = 293;
				continue;

			case 18:
				yyst[yysp] = 18;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 163:
				switch (yytok) {
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr41();
					continue;
				}
				yyn = 293;
				continue;

			case 19:
				yyst[yysp] = 19;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 164:
				switch (yytok) {
				case PLUS:
				case endautomaton:
				case LSBRACK:
					yyn = yyr39();
					continue;
				}
				yyn = 293;
				continue;

			case 20:
				yyst[yysp] = 20;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 165:
				switch (yytok) {
				case LSBRACK:
					yyn = 7;
					continue;
				case PLUS:
					yyn = 43;
					continue;
				case endautomaton:
					yyn = yyr23();
					continue;
				}
				yyn = 293;
				continue;

			case 21:
				yyst[yysp] = 21;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 166:
				switch (yytok) {
				case CAPS:
					yyn = 44;
					continue;
				case NUMERIC:
					yyn = 45;
					continue;
				}
				yyn = 293;
				continue;

			case 22:
				yyst[yysp] = 22;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 167:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr53();
					continue;
				}
				yyn = 293;
				continue;

			case 23:
				yyst[yysp] = 23;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 168:
				yyn = yys23();
				continue;

			case 24:
				yyst[yysp] = 24;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 169:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr21();
					continue;
				}
				yyn = 293;
				continue;

			case 25:
				yyst[yysp] = 25;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 170:
				yyn = yys25();
				continue;

			case 26:
				yyst[yysp] = 26;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 171:
				yyn = yys26();
				continue;

			case 27:
				yyst[yysp] = 27;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 172:
				yyn = yys27();
				continue;

			case 28:
				yyst[yysp] = 28;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 173:
				yyn = yys28();
				continue;

			case 29:
				yyst[yysp] = 29;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 174:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr20();
					continue;
				}
				yyn = 293;
				continue;

			case 30:
				yyst[yysp] = 30;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 175:
				yyn = yys30();
				continue;

			case 31:
				yyst[yysp] = 31;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 176:
				switch (yytok) {
				case URGARC:
				case ARC:
					yyn = yyr25();
					continue;
				}
				yyn = 293;
				continue;

			case 32:
				yyst[yysp] = 32;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 177:
				switch (yytok) {
				case FALSE:
					yyn = 23;
					continue;
				case TRUE:
					yyn = 28;
					continue;
				case VAR:
					yyn = 62;
					continue;
				}
				yyn = 293;
				continue;

			case 33:
				yyst[yysp] = 33;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 178:
				switch (yytok) {
				case VAR:
					yyn = 64;
					continue;
				}
				yyn = 293;
				continue;

			case 34:
				yyst[yysp] = 34;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 179:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 35:
				yyst[yysp] = 35;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 180:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 36:
				yyst[yysp] = 36;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 181:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 37:
				yyst[yysp] = 37;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 182:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 38:
				yyst[yysp] = 38;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 183:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 39:
				yyst[yysp] = 39;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 184:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 40:
				yyst[yysp] = 40;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 185:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 41:
				yyst[yysp] = 41;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 186:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 42:
				yyst[yysp] = 42;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 187:
				switch (yytok) {
				case endautomaton:
					yyn = yyr22();
					continue;
				}
				yyn = 293;
				continue;

			case 43:
				yyst[yysp] = 43;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 188:
				yyn = yys43();
				continue;

			case 44:
				yyst[yysp] = 44;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 189:
				yyn = yys44();
				continue;

			case 45:
				yyst[yysp] = 45;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 190:
				switch (yytok) {
				case VAR:
					yyn = 76;
					continue;
				}
				yyn = 293;
				continue;

			case 46:
				yyst[yysp] = 46;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 191:
				yyn = yys46();
				continue;

			case 47:
				yyst[yysp] = 47;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 192:
				switch (yytok) {
				case CAPS:
					yyn = 44;
					continue;
				case RBRACK:
					yyn = 78;
					continue;
				}
				yyn = 293;
				continue;

			case 48:
				yyst[yysp] = 48;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 193:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr54();
					continue;
				}
				yyn = 293;
				continue;

			case 49:
				yyst[yysp] = 49;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 194:
				switch (yytok) {
				case NUM:
					yyn = 26;
					continue;
				case LBRACK:
					yyn = 49;
					continue;
				case VAR:
					yyn = 66;
					continue;
				}
				yyn = 293;
				continue;

			case 50:
				yyst[yysp] = 50;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 195:
				yyn = yys50();
				continue;

			case 51:
				yyst[yysp] = 51;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 196:
				switch (yytok) {
				case NUM:
					yyn = 80;
					continue;
				}
				yyn = 293;
				continue;

			case 52:
				yyst[yysp] = 52;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 197:
				yyn = yys52();
				continue;

			case 53:
				yyst[yysp] = 53;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 198:
				yyn = yys53();
				continue;

			case 54:
				yyst[yysp] = 54;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 199:
				switch (yytok) {
				case NUM:
					yyn = yyr33();
					continue;
				}
				yyn = 293;
				continue;

			case 55:
				yyst[yysp] = 55;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 200:
				switch (yytok) {
				case NUM:
					yyn = yyr34();
					continue;
				}
				yyn = 293;
				continue;

			case 56:
				yyst[yysp] = 56;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 201:
				switch (yytok) {
				case NUM:
					yyn = yyr35();
					continue;
				}
				yyn = 293;
				continue;

			case 57:
				yyst[yysp] = 57;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 202:
				switch (yytok) {
				case NUM:
					yyn = yyr32();
					continue;
				}
				yyn = 293;
				continue;

			case 58:
				yyst[yysp] = 58;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 203:
				switch (yytok) {
				case NUM:
					yyn = yyr31();
					continue;
				}
				yyn = 293;
				continue;

			case 59:
				yyst[yysp] = 59;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 204:
				switch (yytok) {
				case VAR:
					yyn = 81;
					continue;
				}
				yyn = 293;
				continue;

			case 60:
				yyst[yysp] = 60;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 205:
				switch (yytok) {
				case RSBRACK:
				case CAPS:
					yyn = yyr27();
					continue;
				}
				yyn = 293;
				continue;

			case 61:
				yyst[yysp] = 61;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 206:
				switch (yytok) {
				case CAPS:
					yyn = 82;
					continue;
				case RSBRACK:
					yyn = 83;
					continue;
				}
				yyn = 293;
				continue;

			case 62:
				yyst[yysp] = 62;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 207:
				yyn = yys62();
				continue;

			case 63:
				yyst[yysp] = 63;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 208:
				switch (yytok) {
				case COMMA:
					yyn = 84;
					continue;
				case SEMI:
					yyn = 85;
					continue;
				}
				yyn = 293;
				continue;

			case 64:
				yyst[yysp] = 64;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 209:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr6();
					continue;
				}
				yyn = 293;
				continue;

			case 65:
				yyst[yysp] = 65;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 210:
				yyn = yys65();
				continue;

			case 66:
				yyst[yysp] = 66;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 211:
				switch (yytok) {
				case AUTODECREMENT:
					yyn = 52;
					continue;
				case AUTOINCREMENT:
					yyn = 53;
					continue;
				}
				yyn = 293;
				continue;

			case 67:
				yyst[yysp] = 67;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 212:
				yyn = yys67();
				continue;

			case 68:
				yyst[yysp] = 68;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 213:
				yyn = yys68();
				continue;

			case 69:
				yyst[yysp] = 69;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 214:
				yyn = yys69();
				continue;

			case 70:
				yyst[yysp] = 70;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 215:
				yyn = yys70();
				continue;

			case 71:
				yyst[yysp] = 71;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 216:
				yyn = yys71();
				continue;

			case 72:
				yyst[yysp] = 72;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 217:
				yyn = yys72();
				continue;

			case 73:
				yyst[yysp] = 73;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 218:
				yyn = yys73();
				continue;

			case 74:
				yyst[yysp] = 74;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 219:
				switch (yytok) {
				case PLUS:
				case endautomaton:
				case LSBRACK:
					yyn = yyr38();
					continue;
				}
				yyn = 293;
				continue;

			case 75:
				yyst[yysp] = 75;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 220:
				switch (yytok) {
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr42();
					continue;
				}
				yyn = 293;
				continue;

			case 76:
				yyst[yysp] = 76;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 221:
				switch (yytok) {
				case LSBRACK:
					yyn = 86;
					continue;
				}
				yyn = 293;
				continue;

			case 77:
				yyst[yysp] = 77;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 222:
				yyn = yys77();
				continue;

			case 78:
				yyst[yysp] = 78;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 223:
				switch (yytok) {
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr44();
					continue;
				}
				yyn = 293;
				continue;

			case 79:
				yyst[yysp] = 79;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 224:
				yyn = yys79();
				continue;

			case 80:
				yyst[yysp] = 80;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 225:
				switch (yytok) {
				case RSBRACK:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr29();
					continue;
				}
				yyn = 293;
				continue;

			case 81:
				yyst[yysp] = 81;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 226:
				switch (yytok) {
				case EQ:
					yyn = 54;
					continue;
				case GEQ:
					yyn = 55;
					continue;
				case GR:
					yyn = 56;
					continue;
				case LEQ:
					yyn = 57;
					continue;
				case LS:
					yyn = 58;
					continue;
				}
				yyn = 293;
				continue;

			case 82:
				yyst[yysp] = 82;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 227:
				switch (yytok) {
				case FALSE:
					yyn = 23;
					continue;
				case TRUE:
					yyn = 28;
					continue;
				case VAR:
					yyn = 62;
					continue;
				}
				yyn = 293;
				continue;

			case 83:
				yyst[yysp] = 83;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 228:
				switch (yytok) {
				case URGARC:
				case ARC:
					yyn = yyr24();
					continue;
				}
				yyn = 293;
				continue;

			case 84:
				yyst[yysp] = 84;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 229:
				switch (yytok) {
				case VAR:
					yyn = 89;
					continue;
				}
				yyn = 293;
				continue;

			case 85:
				yyst[yysp] = 85;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 230:
				switch (yytok) {
				case CLOCK_DEC:
					yyn = 90;
					continue;
				}
				yyn = 293;
				continue;

			case 86:
				yyst[yysp] = 86;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 231:
				switch (yytok) {
				case VAR:
					yyn = 93;
					continue;
				case RSBRACK:
				case COMMA:
					yyn = yyr47();
					continue;
				}
				yyn = 293;
				continue;

			case 87:
				yyst[yysp] = 87;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 232:
				switch (yytok) {
				case NUM:
					yyn = 94;
					continue;
				}
				yyn = 293;
				continue;

			case 88:
				yyst[yysp] = 88;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 233:
				switch (yytok) {
				case RSBRACK:
				case CAPS:
					yyn = yyr26();
					continue;
				}
				yyn = 293;
				continue;

			case 89:
				yyst[yysp] = 89;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 234:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr5();
					continue;
				}
				yyn = 293;
				continue;

			case 90:
				yyst[yysp] = 90;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 235:
				switch (yytok) {
				case VAR:
					yyn = 97;
					continue;
				}
				yyn = 293;
				continue;

			case 91:
				yyst[yysp] = 91;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 236:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
					yyn = yyr46();
					continue;
				}
				yyn = 293;
				continue;

			case 92:
				yyst[yysp] = 92;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 237:
				switch (yytok) {
				case COMMA:
					yyn = 98;
					continue;
				case RSBRACK:
					yyn = 99;
					continue;
				}
				yyn = 293;
				continue;

			case 93:
				yyst[yysp] = 93;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 238:
				switch (yytok) {
				case EQ:
					yyn = 100;
					continue;
				}
				yyn = 293;
				continue;

			case 94:
				yyst[yysp] = 94;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 239:
				switch (yytok) {
				case RSBRACK:
				case RBRACK:
				case NUMERIC:
				case CAPS:
					yyn = yyr30();
					continue;
				}
				yyn = 293;
				continue;

			case 95:
				yyst[yysp] = 95;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 240:
				switch (yytok) {
				case COMMA:
					yyn = 101;
					continue;
				case SEMI:
					yyn = 102;
					continue;
				}
				yyn = 293;
				continue;

			case 96:
				yyst[yysp] = 96;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 241:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr8();
					continue;
				}
				yyn = 293;
				continue;

			case 97:
				yyst[yysp] = 97;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 242:
				switch (yytok) {
				case EQ:
					yyn = 103;
					continue;
				}
				yyn = 293;
				continue;

			case 98:
				yyst[yysp] = 98;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 243:
				switch (yytok) {
				case VAR:
					yyn = 93;
					continue;
				}
				yyn = 293;
				continue;

			case 99:
				yyst[yysp] = 99;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 244:
				switch (yytok) {
				case LSBRACK:
					yyn = 105;
					continue;
				}
				yyn = 293;
				continue;

			case 100:
				yyst[yysp] = 100;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 245:
				yyn = yys100();
				continue;

			case 101:
				yyst[yysp] = 101;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 246:
				switch (yytok) {
				case VAR:
					yyn = 97;
					continue;
				}
				yyn = 293;
				continue;

			case 102:
				yyst[yysp] = 102;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 247:
				switch (yytok) {
				case VARIABLE_DEC:
					yyn = 112;
					continue;
				case LSBRACK:
					yyn = yyr4();
					continue;
				}
				yyn = 293;
				continue;

			case 103:
				yyst[yysp] = 103;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 248:
				switch (yytok) {
				case LSBRACK:
					yyn = 113;
					continue;
				}
				yyn = 293;
				continue;

			case 104:
				yyst[yysp] = 104;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 249:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
					yyn = yyr45();
					continue;
				}
				yyn = 293;
				continue;

			case 105:
				yyst[yysp] = 105;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 250:
				switch (yytok) {
				case VAR:
					yyn = 115;
					continue;
				case RSBRACK:
				case COMMA:
					yyn = yyr70();
					continue;
				}
				yyn = 293;
				continue;

			case 106:
				yyst[yysp] = 106;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 251:
				yyn = yys106();
				continue;

			case 107:
				yyst[yysp] = 107;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 252:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case CAPS:
					yyn = yyr51();
					continue;
				}
				yyn = 293;
				continue;

			case 108:
				yyst[yysp] = 108;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 253:
				switch (yytok) {
				case CAPS:
					yyn = 116;
					continue;
				case RSBRACK:
				case COMMA:
					yyn = yyr48();
					continue;
				}
				yyn = 293;
				continue;

			case 109:
				yyst[yysp] = 109;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 254:
				yyn = yys109();
				continue;

			case 110:
				yyst[yysp] = 110;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 255:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr7();
					continue;
				}
				yyn = 293;
				continue;

			case 111:
				yyst[yysp] = 111;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 256:
				switch (yytok) {
				case LSBRACK:
					yyn = yyr2();
					continue;
				}
				yyn = 293;
				continue;

			case 112:
				yyst[yysp] = 112;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 257:
				switch (yytok) {
				case VAR:
					yyn = 121;
					continue;
				}
				yyn = 293;
				continue;

			case 113:
				yyst[yysp] = 113;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 258:
				switch (yytok) {
				case MINUSINF:
					yyn = 123;
					continue;
				case NUMERIC:
					yyn = 124;
					continue;
				case PLUSINF:
					yyn = 125;
					continue;
				}
				yyn = 293;
				continue;

			case 114:
				yyst[yysp] = 114;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 259:
				switch (yytok) {
				case COMMA:
					yyn = 126;
					continue;
				case RSBRACK:
					yyn = 127;
					continue;
				}
				yyn = 293;
				continue;

			case 115:
				yyst[yysp] = 115;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 260:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
					yyn = yyr69();
					continue;
				}
				yyn = 293;
				continue;

			case 116:
				yyst[yysp] = 116;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 261:
				yyn = yys116();
				continue;

			case 117:
				yyst[yysp] = 117;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 262:
				switch (yytok) {
				case CAPS:
					yyn = 116;
					continue;
				case RBRACK:
					yyn = 129;
					continue;
				}
				yyn = 293;
				continue;

			case 118:
				yyst[yysp] = 118;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 263:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr14();
					continue;
				}
				yyn = 293;
				continue;

			case 119:
				yyst[yysp] = 119;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 264:
				switch (yytok) {
				case COMMA:
					yyn = 130;
					continue;
				case SEMI:
					yyn = 131;
					continue;
				}
				yyn = 293;
				continue;

			case 120:
				yyst[yysp] = 120;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 265:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr17();
					continue;
				}
				yyn = 293;
				continue;

			case 121:
				yyst[yysp] = 121;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 266:
				switch (yytok) {
				case EQ:
					yyn = 132;
					continue;
				}
				yyn = 293;
				continue;

			case 122:
				yyst[yysp] = 122;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 267:
				switch (yytok) {
				case POINT:
					yyn = 133;
					continue;
				}
				yyn = 293;
				continue;

			case 123:
				yyst[yysp] = 123;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 268:
				switch (yytok) {
				case RSBRACK:
				case POINT:
					yyn = yyr12();
					continue;
				}
				yyn = 293;
				continue;

			case 124:
				yyst[yysp] = 124;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 269:
				switch (yytok) {
				case RSBRACK:
				case POINT:
					yyn = yyr10();
					continue;
				}
				yyn = 293;
				continue;

			case 125:
				yyst[yysp] = 125;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 270:
				switch (yytok) {
				case RSBRACK:
				case POINT:
					yyn = yyr11();
					continue;
				}
				yyn = 293;
				continue;

			case 126:
				yyst[yysp] = 126;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 271:
				switch (yytok) {
				case VAR:
					yyn = 134;
					continue;
				}
				yyn = 293;
				continue;

			case 127:
				yyst[yysp] = 127;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 272:
				switch (yytok) {
				case PLUS:
				case endautomaton:
				case LSBRACK:
					yyn = yyr40();
					continue;
				}
				yyn = 293;
				continue;

			case 128:
				yyst[yysp] = 128;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 273:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case CAPS:
					yyn = yyr50();
					continue;
				}
				yyn = 293;
				continue;

			case 129:
				yyst[yysp] = 129;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 274:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
				case RBRACK:
				case CAPS:
					yyn = yyr52();
					continue;
				}
				yyn = 293;
				continue;

			case 130:
				yyst[yysp] = 130;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 275:
				switch (yytok) {
				case VAR:
					yyn = 121;
					continue;
				}
				yyn = 293;
				continue;

			case 131:
				yyst[yysp] = 131;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 276:
				switch (yytok) {
				case LSBRACK:
					yyn = yyr3();
					continue;
				}
				yyn = 293;
				continue;

			case 132:
				yyst[yysp] = 132;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 277:
				switch (yytok) {
				case LSBRACK:
					yyn = 113;
					continue;
				case NUMERIC:
					yyn = 136;
					continue;
				case bool:
					yyn = 137;
					continue;
				}
				yyn = 293;
				continue;

			case 133:
				yyst[yysp] = 133;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 278:
				switch (yytok) {
				case POINT:
					yyn = 138;
					continue;
				}
				yyn = 293;
				continue;

			case 134:
				yyst[yysp] = 134;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 279:
				switch (yytok) {
				case RSBRACK:
				case COMMA:
					yyn = yyr68();
					continue;
				}
				yyn = 293;
				continue;

			case 135:
				yyst[yysp] = 135;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 280:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr13();
					continue;
				}
				yyn = 293;
				continue;

			case 136:
				yyst[yysp] = 136;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 281:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr15();
					continue;
				}
				yyn = 293;
				continue;

			case 137:
				yyst[yysp] = 137;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 282:
				switch (yytok) {
				case l_init:
					yyn = 139;
					continue;
				}
				yyn = 293;
				continue;

			case 138:
				yyst[yysp] = 138;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 283:
				switch (yytok) {
				case MINUSINF:
					yyn = 123;
					continue;
				case NUMERIC:
					yyn = 124;
					continue;
				case PLUSINF:
					yyn = 125;
					continue;
				}
				yyn = 293;
				continue;

			case 139:
				yyst[yysp] = 139;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 284:
				switch (yytok) {
				case FALSE:
					yyn = 23;
					continue;
				case TRUE:
					yyn = 28;
					continue;
				}
				yyn = 293;
				continue;

			case 140:
				yyst[yysp] = 140;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 285:
				switch (yytok) {
				case RSBRACK:
					yyn = 142;
					continue;
				}
				yyn = 293;
				continue;

			case 141:
				yyst[yysp] = 141;
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 286:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr16();
					continue;
				}
				yyn = 293;
				continue;

			case 142:
				yyst[yysp] = 142;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 287:
				switch (yytok) {
				case l_init:
					yyn = 143;
					continue;
				}
				yyn = 293;
				continue;

			case 143:
				yyst[yysp] = 143;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 288:
				switch (yytok) {
				case NUMERIC:
					yyn = 144;
					continue;
				}
				yyn = 293;
				continue;

			case 144:
				yyst[yysp] = 144;
				yysv[yysp] = (lexer.semanticValue);
				yytok = (nextToken());
				if (++yysp >= yyst.length) {
					yyexpand();
				}
			case 289:
				switch (yytok) {
				case SEMI:
				case COMMA:
					yyn = yyr9();
					continue;
				}
				yyn = 293;
				continue;

			case 290:
				return true;
			case 291:
				yyerror("stack overflow");
			case 292:
				return false;
			case 293:
				yyerror("syntax error");
				return false;
			}
		}
	}

	protected void yyexpand() {
		int[] newyyst = new int[2 * yyst.length];
		Object[] newyysv = new Object[2 * yyst.length];
		for (int i = 0; i < yyst.length; i++) {
			newyyst[i] = yyst[i];
			newyysv[i] = yysv[i];
		}
		yyst = newyyst;
		yysv = newyysv;
	}

	private int yys9() {
		switch (yytok) {
		case FALSE:
			return 23;
		case FF:
			return 24;
		case LBRACK:
			return 25;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TRUE:
			return 28;
		case TT:
			return 29;
		case VAR:
			return 30;
		}
		return 293;
	}

	private int yys10() {
		switch (yytok) {
		case TILDE:
		case LBRACK:
		case NUM:
		case FF:
		case FALSE:
		case VAR:
		case TT:
		case TRUE:
			return yyr36();
		}
		return 293;
	}

	private int yys11() {
		switch (yytok) {
		case TILDE:
		case LBRACK:
		case NUM:
		case FF:
		case FALSE:
		case VAR:
		case TT:
		case TRUE:
			return yyr37();
		}
		return 293;
	}

	private int yys15() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case EQ:
			return 35;
		case LEQ:
			return 36;
		case LS:
			return 37;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		}
		return 293;
	}

	private int yys23() {
		switch (yytok) {
		case SEMI:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr19();
		}
		return 293;
	}

	private int yys25() {
		switch (yytok) {
		case FALSE:
			return 23;
		case FF:
			return 24;
		case LBRACK:
			return 25;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TRUE:
			return 28;
		case TT:
			return 29;
		case VAR:
			return 30;
		}
		return 293;
	}

	private int yys26() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr59();
		}
		return 293;
	}

	private int yys27() {
		switch (yytok) {
		case FF:
			return 24;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TT:
			return 29;
		case LBRACK:
			return 49;
		case VAR:
			return 50;
		}
		return 293;
	}

	private int yys28() {
		switch (yytok) {
		case SEMI:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr18();
		}
		return 293;
	}

	private int yys30() {
		switch (yytok) {
		case AUTODECREMENT:
			return 52;
		case AUTOINCREMENT:
			return 53;
		case EQ:
			return 54;
		case GEQ:
			return 55;
		case GR:
			return 56;
		case LEQ:
			return 57;
		case LS:
			return 58;
		case MINUS:
			return 59;
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr55();
		}
		return 293;
	}

	private int yys43() {
		switch (yytok) {
		case FALSE:
			return 23;
		case FF:
			return 24;
		case LBRACK:
			return 25;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TRUE:
			return 28;
		case TT:
			return 29;
		case VAR:
			return 30;
		}
		return 293;
	}

	private int yys44() {
		switch (yytok) {
		case FALSE:
			return 23;
		case FF:
			return 24;
		case LBRACK:
			return 25;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TRUE:
			return 28;
		case TT:
			return 29;
		case VAR:
			return 30;
		}
		return 293;
	}

	private int yys46() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case EQ:
			return 35;
		case LEQ:
			return 36;
		case LS:
			return 37;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		case RBRACK:
			return 77;
		}
		return 293;
	}

	private int yys50() {
		switch (yytok) {
		case AUTODECREMENT:
			return 52;
		case AUTOINCREMENT:
			return 53;
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr55();
		}
		return 293;
	}

	private int yys52() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr67();
		}
		return 293;
	}

	private int yys53() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr66();
		}
		return 293;
	}

	private int yys62() {
		switch (yytok) {
		case EQ:
			return 54;
		case GEQ:
			return 55;
		case GR:
			return 56;
		case LEQ:
			return 57;
		case LS:
			return 58;
		case MINUS:
			return 59;
		}
		return 293;
	}

	private int yys65() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr63();
		}
		return 293;
	}

	private int yys67() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr56();
		}
		return 293;
	}

	private int yys68() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr57();
		}
		return 293;
	}

	private int yys69() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case NUMERIC:
		case CAPS:
			return yyr58();
		}
		return 293;
	}

	private int yys70() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr62();
		}
		return 293;
	}

	private int yys71() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr64();
		}
		return 293;
	}

	private int yys72() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr60();
		}
		return 293;
	}

	private int yys73() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr61();
		}
		return 293;
	}

	private int yys77() {
		switch (yytok) {
		case LEQ:
		case RSBRACK:
		case COMMA:
		case RBRACK:
		case PLUS:
		case NUMERIC:
		case MOD:
		case CAPS:
		case MINUS:
		case EQ:
		case TIMES:
		case LS:
		case DIVIDE:
			return yyr65();
		}
		return 293;
	}

	private int yys79() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		case RBRACK:
			return 77;
		}
		return 293;
	}

	private int yys100() {
		switch (yytok) {
		case FF:
			return 24;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TT:
			return 29;
		case VAR:
			return 50;
		case LBRACK:
			return 109;
		}
		return 293;
	}

	private int yys106() {
		switch (yytok) {
		case DIVIDE:
			return 34;
		case EQ:
			return 35;
		case LEQ:
			return 36;
		case LS:
			return 37;
		case MINUS:
			return 38;
		case MOD:
			return 39;
		case PLUS:
			return 40;
		case TIMES:
			return 41;
		case RSBRACK:
		case COMMA:
			return yyr49();
		}
		return 293;
	}

	private int yys109() {
		switch (yytok) {
		case FF:
			return 24;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TT:
			return 29;
		case VAR:
			return 50;
		case LBRACK:
			return 109;
		}
		return 293;
	}

	private int yys116() {
		switch (yytok) {
		case FF:
			return 24;
		case NUM:
			return 26;
		case TILDE:
			return 27;
		case TT:
			return 29;
		case VAR:
			return 50;
		case LBRACK:
			return 109;
		}
		return 293;
	}

	private int yyr1() { // AUTOMATON_DEF : automaton DECLARATIONS STATES
							// endautomaton
		{/* EMPTY PRODUCTION */
		}
		yysv[yysp -= 4] = yyrv;
		return 1;
	}

	private int yyr36() { // ARCS : ARC
		{
			System.out.println("Arch");
			yyrv = new Boolean(false);
		}
		yysv[yysp -= 1] = yyrv;
		return 9;
	}

	private int yyr37() { // ARCS : URGARC
		{
			System.out.println("Urgent arch");
			yyrv = new Boolean(true);
		}
		yysv[yysp -= 1] = yyrv;
		return 9;
	}

	private int yyr48() { // ASSIGN : VAR EQ BEXPRS
		{
			yyrv = new Assign(((String) yysv[yysp - 3]),
					((BooleanExpression) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypASSIGN();
	}

	private int yyr49() { // ASSIGN : VAR EQ AEXPR
		{
			yyrv = new Assign(((String) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypASSIGN();
	}

	private int yypASSIGN() {
		switch (yyst[yysp - 1]) {
		case 86:
			return 91;
		default:
			return 104;
		}
	}

	private int yyr45() { // ASSIGNMENT : ASSIGNMENT COMMA ASSIGN
		{
			ArrayList<Assign> temp = new ArrayList<Assign>();
			temp.addAll(((ArrayList) yysv[yysp - 3]));
			temp.add(((Assign) yysv[yysp - 1]));
			yyrv = temp;
		}
		yysv[yysp -= 3] = yyrv;
		return 92;
	}

	private int yyr46() { // ASSIGNMENT : ASSIGN
		{
			ArrayList<Assign> temp = new ArrayList<Assign>();
			temp.add(((Assign) yysv[yysp - 1]));
			yyrv = temp;
		}
		yysv[yysp -= 1] = yyrv;
		return 92;
	}

	private int yyr47() { // ASSIGNMENT : /* empty */
		{
			yyrv = new ArrayList<Assign>();
		}
		yysv[yysp -= 0] = yyrv;
		return 92;
	}

	private int yyr59() { // AEXPR : NUM
		{
			yyrv = new ArithmeticExpression(((Integer) yysv[yysp - 1]));
		}
		yysv[yysp -= 1] = yyrv;
		return yypAEXPR();
	}

	private int yyr60() { // AEXPR : AEXPR PLUS AEXPR
		{
			yyrv = new ArithmeticExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), '+');
		}
		yysv[yysp -= 3] = yyrv;
		return yypAEXPR();
	}

	private int yyr61() { // AEXPR : AEXPR TIMES AEXPR
		{
			yyrv = new ArithmeticExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), '*');
		}
		yysv[yysp -= 3] = yyrv;
		return yypAEXPR();
	}

	private int yyr62() { // AEXPR : AEXPR MINUS AEXPR
		{
			yyrv = new ArithmeticExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), '-');
		}
		yysv[yysp -= 3] = yyrv;
		return yypAEXPR();
	}

	private int yyr63() { // AEXPR : AEXPR DIVIDE AEXPR
		{
			yyrv = new ArithmeticExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), '/');
		}
		yysv[yysp -= 3] = yyrv;
		return yypAEXPR();
	}

	private int yyr64() { // AEXPR : AEXPR MOD AEXPR
		{
			yyrv = new ArithmeticExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), '%');
		}
		yysv[yysp -= 3] = yyrv;
		return yypAEXPR();
	}

	private int yyr65() { // AEXPR : LBRACK AEXPR RBRACK
		{
			yyrv = ((ArithmeticExpression) yysv[yysp - 2]);
		}
		yysv[yysp -= 3] = yyrv;
		return yypAEXPR();
	}

	private int yyr66() { // AEXPR : VAR AUTOINCREMENT
		{
			float value = 0;
			for (Declaration d : listOfVariables) {
				if (d.getVar().equalsIgnoreCase(((String) yysv[yysp - 2]))) {
					value = d.getValue();
					break;
				}
			}
			yyrv = new ArithmeticExpression(((String) yysv[yysp - 2]), 'p',
					value);
		}
		yysv[yysp -= 2] = yyrv;
		return yypAEXPR();
	}

	private int yyr67() { // AEXPR : VAR AUTODECREMENT
		{
			float value = 0;
			for (Declaration d : listOfVariables) {
				if (d.getVar().equalsIgnoreCase(((String) yysv[yysp - 2]))) {
					value = d.getValue();
					break;
				}
			}
			yyrv = new ArithmeticExpression(((String) yysv[yysp - 2]), 'm',
					value);
		}
		yysv[yysp -= 2] = yyrv;
		return yypAEXPR();
	}

	private int yypAEXPR() {
		switch (yyst[yysp - 1]) {
		case 109:
			return 46;
		case 100:
			return 106;
		case 49:
			return 79;
		case 41:
			return 73;
		case 40:
			return 72;
		case 39:
			return 71;
		case 38:
			return 70;
		case 37:
			return 69;
		case 36:
			return 68;
		case 35:
			return 67;
		case 34:
			return 65;
		case 25:
			return 46;
		default:
			return 15;
		}
	}

	private int yyr53() { // BEXPR : SHORTBOOL
		{
			yyrv = new BooleanExpression(((Boolean) yysv[yysp - 1]));
		}
		yysv[yysp -= 1] = yyrv;
		return yypBEXPR();
	}

	private int yyr54() { // BEXPR : TILDE BEXPR
		{
			yyrv = new BooleanExpression(((BooleanExpression) yysv[yysp - 1]),
					Constant.NOT);
		}
		yysv[yysp -= 2] = yyrv;
		return yypBEXPR();
	}

	private int yyr55() { // BEXPR : VAR
		{
			yyrv = new BooleanExpression(((String) yysv[yysp - 1]));
		}
		yysv[yysp -= 1] = yyrv;
		return yypBEXPR();
	}

	private int yyr56() { // BEXPR : AEXPR EQ AEXPR
		{
			yyrv = new BooleanExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), Constant.EQ);
		}
		yysv[yysp -= 3] = yyrv;
		return yypBEXPR();
	}

	private int yyr57() { // BEXPR : AEXPR LEQ AEXPR
		{
			yyrv = new BooleanExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), Constant.LEQ);
		}
		yysv[yysp -= 3] = yyrv;
		return yypBEXPR();
	}

	private int yyr58() { // BEXPR : AEXPR LS AEXPR
		{
			yyrv = new BooleanExpression(
					((ArithmeticExpression) yysv[yysp - 3]),
					((ArithmeticExpression) yysv[yysp - 1]), Constant.LS);
		}
		yysv[yysp -= 3] = yyrv;
		return yypBEXPR();
	}

	private int yypBEXPR() {
		switch (yyst[yysp - 1]) {
		case 116:
			return 107;
		case 109:
			return 107;
		case 100:
			return 107;
		case 27:
			return 48;
		default:
			return 16;
		}
	}

	private int yyr50() { // BEXPRS : BEXPRS CAPS BEXPRS
		{
			yyrv = new BooleanExpression(((BooleanExpression) yysv[yysp - 3]),
					((BooleanExpression) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypBEXPRS();
	}

	private int yyr51() { // BEXPRS : BEXPR
		yysp -= 1;
		return yypBEXPRS();
	}

	private int yyr52() { // BEXPRS : LBRACK BEXPRS RBRACK
		{
			yyrv = ((BooleanExpression) yysv[yysp - 2]);
		}
		yysv[yysp -= 3] = yyrv;
		return yypBEXPRS();
	}

	private int yypBEXPRS() {
		switch (yyst[yysp - 1]) {
		case 109:
			return 117;
		case 100:
			return 108;
		default:
			return 128;
		}
	}

	private int yyr18() { // BOOLEAN : TRUE
		{
			yyrv = new Boolean(true);
		}
		yysv[yysp -= 1] = yyrv;
		return yypBOOLEAN();
	}

	private int yyr19() { // BOOLEAN : FALSE
		{
			yyrv = new Boolean(false);
		}
		yysv[yysp -= 1] = yyrv;
		return yypBOOLEAN();
	}

	private int yypBOOLEAN() {
		switch (yyst[yysp - 1]) {
		case 139:
			return 141;
		default:
			return 17;
		}
	}

	private int yyr7() { // CLOCK_DECLARATION : CLOCK_DECLARATION COMMA
							// NUMERIC_REST
		yysp -= 3;
		return 95;
	}

	private int yyr8() { // CLOCK_DECLARATION : NUMERIC_REST
		yysp -= 1;
		return 95;
	}

	private int yyr28() { // CONSTRAINT : BOOLEAN
		{
			yyrv = new ConstraintExpression(((Boolean) yysv[yysp - 1]));
		}
		yysv[yysp -= 1] = yyrv;
		return yypCONSTRAINT();
	}

	private int yyr29() { // CONSTRAINT : VAR SIM NUM
		{
			yyrv = new ConstraintExpression(((String) yysv[yysp - 3]),
					((Integer) yysv[yysp - 2]), ((Integer) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypCONSTRAINT();
	}

	private int yyr30() { // CONSTRAINT : VAR MINUS VAR SIM NUM
		{
			yyrv = new ConstraintExpression(((String) yysv[yysp - 5]),
					((String) yysv[yysp - 3]), ((Integer) yysv[yysp - 2]),
					((Integer) yysv[yysp - 1]));
		}
		yysv[yysp -= 5] = yyrv;
		return yypCONSTRAINT();
	}

	private int yypCONSTRAINT() {
		switch (yyst[yysp - 1]) {
		case 82:
			return 60;
		case 32:
			return 60;
		default:
			return 18;
		}
	}

	private int yyr26() { // CONSTRAINTS : CONSTRAINTS CAPS CONSTRAINTS
		{
			yyrv = new ConstraintExpression(
					((ConstraintExpression) yysv[yysp - 3]),
					((ConstraintExpression) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypCONSTRAINTS();
	}

	private int yyr27() { // CONSTRAINTS : CONSTRAINT
		yysp -= 1;
		return yypCONSTRAINTS();
	}

	private int yypCONSTRAINTS() {
		switch (yyst[yysp - 1]) {
		case 32:
			return 61;
		default:
			return 88;
		}
	}

	private int yyr15() { // DECLARATION : VAR EQ NUMERIC
		{
			System.out.println("Declaration:" + ((String) yysv[yysp - 3]) + "="
					+ ((Float) yysv[yysp - 1]));
			Declaration variable = new Declaration(((String) yysv[yysp - 3]),
					((Float) yysv[yysp - 1]));
			if (listOfNames.contains(((String) yysv[yysp - 3]))) {
				errorString = "The name (variable) "
						+ ((String) yysv[yysp - 3]) + " is already used";
				return error;
			}
			listOfVariables.add(variable);
			listOfNames.add(((String) yysv[yysp - 3]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypDECLARATION();
	}

	private int yyr16() { // DECLARATION : VAR EQ bool l_init BOOLEAN
		{
			System.out.println("Declaration:" + ((String) yysv[yysp - 5])
					+ " set at " + ((Boolean) yysv[yysp - 1]));
			if (listOfNames.contains(((String) yysv[yysp - 5]))) {
				errorString = "The name (variable) "
						+ ((String) yysv[yysp - 5]) + " is already used";
				return error;
			}
			Declaration variable;
			if (((Boolean) yysv[yysp - 1]) == true) {
				variable = new Declaration(((String) yysv[yysp - 5]),
						((Boolean) yysv[yysp - 1]));
			} else {
				variable = new Declaration(((String) yysv[yysp - 5]),
						((Boolean) yysv[yysp - 1]));
			}
			listOfVariables.add(variable);
			listOfNames.add(((String) yysv[yysp - 5]));
		}
		yysv[yysp -= 5] = yyrv;
		return yypDECLARATION();
	}

	private int yyr17() { // DECLARATION : NUMERIC_REST
		{

		}
		yysv[yysp -= 1] = yyrv;
		return yypDECLARATION();
	}

	private int yypDECLARATION() {
		switch (yyst[yysp - 1]) {
		case 112:
			return 118;
		default:
			return 135;
		}
	}

	private int yyr2() { // DECLARATIONS : maxtime EQ NUM NODE_DEC
							// NODE_DECLARATION SEMI CLOCK_DEC CLOCK_DECLARATION
							// SEMI VARIABLESORNOT
		{
			max = ((Integer) yysv[yysp - 8]);
			// Create the array of declarations for the semantics application
			listOfClocks.add(new Declaration("MAXTIME", max)); // ...but first
																// add the
																// MAXTIME clock
																// to the clocks
																// structure
			decs = new Declaration[listOfClocks.size() + listOfVariables.size()];
			for (int i = 0; i < listOfClocks.size(); i++)
				decs[i] = listOfClocks.get(i);
			for (int i = 0; i < listOfVariables.size(); i++)
				decs[i + listOfClocks.size()] = listOfVariables.get(i);
			System.out.println("List of clocks/variables correctly created...");
		}
		yysv[yysp -= 10] = yyrv;
		return 3;
	}

	private int yyr13() { // DEFINITIONS : DEFINITIONS COMMA DECLARATION
		yysp -= 3;
		return 119;
	}

	private int yyr14() { // DEFINITIONS : DECLARATION
		yysp -= 1;
		return 119;
	}

	private int yyr40() { // EDGE : GUARD NUMERIC VAR LSBRACK ASSIGNMENT RSBRACK
							// LSBRACK RESET RSBRACK
		{// System.out.println("Probability " + ((Float)yysv[yysp-8]) +
			// ", arrival node: " + ((String)yysv[yysp-7]));
			yyrv = new Edge(((Guard) yysv[yysp - 9]), ((Float) yysv[yysp - 8]),
					((String) yysv[yysp - 7]), ((ArrayList) yysv[yysp - 5]),
					((ArrayList) yysv[yysp - 2]), false);
		}
		yysv[yysp -= 9] = yyrv;
		switch (yyst[yysp - 1]) {
		case 9:
			return 19;
		default:
			return 74;
		}
	}

	private int yyr38() { // EDGE_SET : EDGE_SET PLUS EDGE
		{
			((ArrayList) yysv[yysp - 3]).add(((Edge) yysv[yysp - 1]));
			for (int i = 0; i < ((ArrayList) yysv[yysp - 3]).size() - 1; i++) {
				System.out.print(((Edge) ((ArrayList) yysv[yysp - 3]).get(i))
						.getProbability() + " -- ");
			}
			System.out.println(((Edge) ((ArrayList) yysv[yysp - 3])
					.get(((ArrayList) yysv[yysp - 3]).size() - 1))
					.getProbability());
			yyrv = ((ArrayList) yysv[yysp - 3]);
		}
		yysv[yysp -= 3] = yyrv;
		return 20;
	}

	private int yyr39() { // EDGE_SET : EDGE
		{
			System.out.println("EDGE");
			System.out.println(((Edge) yysv[yysp - 1]).getProbability());
			ArrayList<Edge> list = new ArrayList<Edge>();
			list.add(((Edge) yysv[yysp - 1]));
			yyrv = list;
		}
		yysv[yysp -= 1] = yyrv;
		return 20;
	}

	private int yyr41() { // GUARD : CONSTRAINT
		{
			yyrv = new Guard(((ConstraintExpression) yysv[yysp - 1]));
		}
		yysv[yysp -= 1] = yyrv;
		return yypGUARD();
	}

	private int yyr42() { // GUARD : GUARD CAPS GUARD
		{
			yyrv = new Guard(((Guard) yysv[yysp - 3]), ((Guard) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return yypGUARD();
	}

	private int yyr43() { // GUARD : BEXPR
		{
			yyrv = new Guard(((BooleanExpression) yysv[yysp - 1]));
		}
		yysv[yysp -= 1] = yyrv;
		return yypGUARD();
	}

	private int yyr44() { // GUARD : LBRACK GUARD RBRACK
		{
			yyrv = ((Guard) yysv[yysp - 2]);
		}
		yysv[yysp -= 3] = yyrv;
		return yypGUARD();
	}

	private int yypGUARD() {
		switch (yyst[yysp - 1]) {
		case 44:
			return 75;
		case 25:
			return 47;
		default:
			return 21;
		}
	}

	private int yyr24() { // NODE : LSBRACK VAR SEPARATOR CONSTRAINTS RSBRACK
		{
			locations.put(((String) yysv[yysp - 4]),
					((ConstraintExpression) yysv[yysp - 2]));
			yyrv = ((String) yysv[yysp - 4]);
		}
		yysv[yysp -= 5] = yyrv;
		return 5;
	}

	private int yyr25() { // NODE : LSBRACK VAR RSBRACK
		{
			locations.put(((String) yysv[yysp - 2]), null);
			yyrv = ((String) yysv[yysp - 2]);
		}
		yysv[yysp -= 3] = yyrv;
		return 5;
	}

	private int yyr5() { // NODE_DECLARATION : NODE_DECLARATION COMMA VAR
		{
			System.out.println("Node acquired: " + ((String) yysv[yysp - 1]));
			// insert the control to verify the presence of
			// ((String)yysv[yysp-1]) in the variable list
			if (listOfNames.contains(((String) yysv[yysp - 1]))) {
				errorString = "The name (node) " + ((String) yysv[yysp - 1])
						+ " is already used";
				return error;
			}
			listOfNames.add(((String) yysv[yysp - 1]));
		}
		yysv[yysp -= 3] = yyrv;
		return 63;
	}

	private int yyr6() { // NODE_DECLARATION : VAR
		{
			System.out.println("Node acquired: " + ((String) yysv[yysp - 1]));
			// insert the control to verify the presence of
			// ((String)yysv[yysp-1]) in the variable list
			if (listOfNames.contains(((String) yysv[yysp - 1]))) {
				errorString = "The name (node) " + ((String) yysv[yysp - 1])
						+ " is already used";
				return error;
			}
			listOfNames.add(((String) yysv[yysp - 1]));
			if (startLocation.isEmpty())
				startLocation = ((String) yysv[yysp - 1]);
		}
		yysv[yysp -= 1] = yyrv;
		return 63;
	}

	private int yyr9() { // NUMERIC_REST : VAR EQ LSBRACK RANGEFLT POINT POINT
							// RANGEFLT RSBRACK l_init NUMERIC
		{
			System.out.println("Variable acquired: "
					+ ((String) yysv[yysp - 10]));
			Declaration variable = new Declaration(((String) yysv[yysp - 10]),
					((Float) yysv[yysp - 1]), ((Float) yysv[yysp - 7]),
					((Float) yysv[yysp - 4]));
			if (listOfNames.contains(((String) yysv[yysp - 10]))) {
				errorString = "the name (variable) "
						+ ((String) yysv[yysp - 10]) + " is already used";
				return error;
			}
			if (!variable.isRangeCorrect()) {
				errorString = "Error in the range of the variable "
						+ ((String) yysv[yysp - 10]) + " control it!";
				return error;
			}
			listOfClocks.add(variable);
			listOfNames.add(((String) yysv[yysp - 10]));
		}
		yysv[yysp -= 10] = yyrv;
		switch (yyst[yysp - 1]) {
		case 101:
			return 110;
		case 90:
			return 96;
		default:
			return 120;
		}
	}

	private int yyr10() { // RANGEFLT : NUMERIC
		{
			yyrv = ((Float) yysv[yysp - 1]);
		}
		yysv[yysp -= 1] = yyrv;
		return yypRANGEFLT();
	}

	private int yyr11() { // RANGEFLT : PLUSINF
		{
			yyrv = new Float(Float.MAX_VALUE);
		}
		yysv[yysp -= 1] = yyrv;
		return yypRANGEFLT();
	}

	private int yyr12() { // RANGEFLT : MINUSINF
		{
			yyrv = new Float(Float.MIN_VALUE);
		}
		yysv[yysp -= 1] = yyrv;
		return yypRANGEFLT();
	}

	private int yypRANGEFLT() {
		switch (yyst[yysp - 1]) {
		case 113:
			return 122;
		default:
			return 140;
		}
	}

	private int yyr68() { // RESET : RESET COMMA VAR
		{
			System.out.println("Reset " + ((String) yysv[yysp - 1]));
			ArrayList support = new ArrayList<Integer>();
			support.addAll(((ArrayList) yysv[yysp - 3]));
			support.add(new Integer(Utility.getLiteralIndex(
					((String) yysv[yysp - 1]), decs)));
			yyrv = support;
		}
		yysv[yysp -= 3] = yyrv;
		return 114;
	}

	private int yyr69() { // RESET : VAR
		{
			System.out.println("Reset " + ((String) yysv[yysp - 1]));
			ArrayList support = new ArrayList<Integer>();
			support.add(new Integer(Utility.getLiteralIndex(
					((String) yysv[yysp - 1]), decs)));
			yyrv = support;
		}
		yysv[yysp -= 1] = yyrv;
		return 114;
	}

	private int yyr70() { // RESET : /* empty */
		{
			yyrv = null;
		}
		yysv[yysp -= 0] = yyrv;
		return 114;
	}

	private int yyr20() { // SHORTBOOL : TT
		{
			yyrv = new Boolean(true);
		}
		yysv[yysp -= 1] = yyrv;
		return 22;
	}

	private int yyr21() { // SHORTBOOL : FF
		{
			yyrv = new Boolean(false);
		}
		yysv[yysp -= 1] = yyrv;
		return 22;
	}

	private int yyr31() { // SIM : LS
		{
			yyrv = new Integer(Constant.LS);
		}
		yysv[yysp -= 1] = yyrv;
		return yypSIM();
	}

	private int yyr32() { // SIM : LEQ
		{
			yyrv = new Integer(Constant.LEQ);
		}
		yysv[yysp -= 1] = yyrv;
		return yypSIM();
	}

	private int yyr33() { // SIM : EQ
		{
			yyrv = new Integer(Constant.EQ);
		}
		yysv[yysp -= 1] = yyrv;
		return yypSIM();
	}

	private int yyr34() { // SIM : GEQ
		{
			yyrv = new Integer(Constant.GEQ);
		}
		yysv[yysp -= 1] = yyrv;
		return yypSIM();
	}

	private int yyr35() { // SIM : GR
		{
			yyrv = new Integer(Constant.GR);
		}
		yysv[yysp -= 1] = yyrv;
		return yypSIM();
	}

	private int yypSIM() {
		switch (yyst[yysp - 1]) {
		case 81:
			return 87;
		default:
			return 51;
		}
	}

	private int yyr22() { // STATES : NODE ARCS EDGE_SET STATES
		{
			float prob_sum = 0;
			for (int i = 0; i < ((ArrayList) yysv[yysp - 2]).size(); i++) {
				prob_sum += ((Edge) ((ArrayList) yysv[yysp - 2]).get(i))
						.getProbability();
			}
			if (prob_sum != 1) {
				errorString = "The sum of the probability inserted in the multiarch is different from 1 and is"
						+ prob_sum;
				return error;
			} else {

				if (((Boolean) yysv[yysp - 3]).booleanValue()) {
					if (!urEdges.containsKey(((String) yysv[yysp - 4])))
						urEdges.put(((String) yysv[yysp - 4]),
								new ArrayList<ArrayList<Edge>>());
					urEdges.get(((String) yysv[yysp - 4])).add(
							((ArrayList) yysv[yysp - 2]));
				} else {
					if (!edges.containsKey(((String) yysv[yysp - 4])))
						edges.put(((String) yysv[yysp - 4]),
								new ArrayList<ArrayList<Edge>>());
					edges.get(((String) yysv[yysp - 4])).add(
							((ArrayList) yysv[yysp - 2]));
				}
			}
		}
		yysv[yysp -= 4] = yyrv;
		return yypSTATES();
	}

	private int yyr23() { // STATES : NODE ARCS EDGE_SET
		{
			float prob_sum = 0;
			for (int i = 0; i < ((ArrayList) yysv[yysp - 1]).size(); i++) {
				prob_sum += ((Edge) ((ArrayList) yysv[yysp - 1]).get(i))
						.getProbability();
			}
			if (prob_sum != 1) {
				errorString = "The sum of the probability inserted in the multiarch is different from 1 and is"
						+ prob_sum;
				return error;
			} else {

				if (((Boolean) yysv[yysp - 2]).booleanValue()) {
					if (!urEdges.containsKey(((String) yysv[yysp - 3])))
						urEdges.put(((String) yysv[yysp - 3]),
								new ArrayList<ArrayList<Edge>>());
					urEdges.get(((String) yysv[yysp - 3])).add(
							((ArrayList) yysv[yysp - 1]));
				} else {
					if (!edges.containsKey(((String) yysv[yysp - 3])))
						edges.put(((String) yysv[yysp - 3]),
								new ArrayList<ArrayList<Edge>>());
					edges.get(((String) yysv[yysp - 3])).add(
							((ArrayList) yysv[yysp - 1]));
				}
			}
		}
		yysv[yysp -= 3] = yyrv;
		return yypSTATES();
	}

	private int yypSTATES() {
		switch (yyst[yysp - 1]) {
		case 3:
			return 6;
		default:
			return 42;
		}
	}

	private int yyr3() { // VARIABLESORNOT : VARIABLE_DEC DEFINITIONS SEMI
		{
			// does nothing!
		}
		yysv[yysp -= 3] = yyrv;
		return 111;
	}

	private int yyr4() { // VARIABLESORNOT : /* empty */
		{
			// does nothing!
		}
		yysv[yysp -= 0] = yyrv;
		return 111;
	}

	protected String[] yyerrmsgs = {};

	/** Reference to the used lexical analyzer instance. */
	private FishPassLexer lexer;

	/** Loaded with a string indicating the error position, if one occurs */
	private String errorString = "";

	// DATA STRUCTURE FOR STORING AUTOMATON INFORMATION
	/** <code>Map</code> with all the automaton edges, for each location */
	private HashMap<String, ArrayList<ArrayList<Edge>>> edges = new HashMap<String, ArrayList<ArrayList<Edge>>>();
	/** <code>Map</code> with all the automaton URGENT edges, for each location */
	private HashMap<String, ArrayList<ArrayList<Edge>>> urEdges = new HashMap<String, ArrayList<ArrayList<Edge>>>();
	// used to check COLLISIONS among locations, clocks and variables
	/** <code>ArrayList</code> with all the declared automaton names */
	private ArrayList<String> listOfNames = new ArrayList<String>();

	/**
	 * <code>Map</code> with all the automaton locations and corresponding
	 * invariants
	 */
	private HashMap<String, ConstraintExpression> locations = new HashMap<String, ConstraintExpression>();
	/** <code>ArrayList</code> with all the declared automaton clocks */
	private ArrayList<Declaration> listOfClocks = new ArrayList<Declaration>();
	/** <code>ArrayList</code> with all the declared automaton variables */
	private ArrayList<Declaration> listOfVariables = new ArrayList<Declaration>();
	/** <code>Array</code> of <code>Declaration</code>s for clocks and variables */
	private Declaration[] decs;
	/** <code>ArrayList</code> with all the declared automaton variables */
	private ArrayList<Qvi> workingQueue = new ArrayList<Qvi>();
	/**
	 * Initial EPDTA location: it is ALWAYS the FIRST location declared in the
	 * input
	 */
	private String startLocation = "";
	/** Max time execution input for the EPDTA */
	private int max;

	// METHOD SECTION. THEY OPERATE ON THE PARSER FIELDS AND ON THE PARSER
	// OUTPUT

	/**
	 * Returns a string representing the error the parser encountered.
	 * 
	 * @return the <code>String</code> representing the error occurred
	 */
	public String getError() {
		return errorString;
	}

	/**
	 * Error function called from the parser for syntax error in the token
	 * input. If an incorrect token (i.e. an unrecognizable token) is found from
	 * the lexer or else when "error" token is returned in the semantics meaning
	 * the tokens found are not acceptable in the particular context.
	 */
	private void yyerror(String msg) {
		String err = "Error at line " + (lexer.linenr() + 1)
				+ " and at column " + (lexer.columnnr() + 1)
				+ " with character(s) \"" + lexer.yytext() + "\".\n";
		err = err + errorString;
		System.out.println(err);
	}

	/**
	 * Called from the parser to get the next available token.
	 * 
	 * @return the <code>integer</code> value associated with the next token or
	 *         the <code>error token</code> if an error occurs, or
	 *         <code>endofinput token</code> if no more token are available
	 */
	private int nextToken() {
		try {
			return lexer.yylex();
		} catch (Exception e) {
			return error;
		}
	}

	public ArrayList<Declaration> getVariables() {
		return listOfVariables;
	}

	public ArrayList<Declaration> getClocks() {
		return listOfClocks;
	}

	public MDPGraph<String, MultiArc> createMDP(String input) {
		// 1) Clear support data structures and variables
		startLocation = ""; // TODO metodo di pulitura delle strutture di
							// supporto
		// 2) Parsing the input file [loading support data structures]
		if (parseInput(input)) {
			// 3) Semantics application EPDTA --> MDP
			return epdta2mdp();
		}
		return null;
	}

	private boolean parseInput(String inputFile) {
		try {
			lexer = new FishPassLexer(new FileReader(inputFile));
			lexer.yylex();
			if (!parse()) {
				System.out.print("Parsing error - abort...");
				System.out.print("Parser error status: "
						+ (yyerrno > 0 ? yyerrmsgs[yyerrno] : "unknown"));
				return false;
			}
		} catch (Exception Ex) {
			return false;
		}
		return true;
	}

	private MDPGraph<String, MultiArc> epdta2mdp() {
		try {
			// 1) Initial (Q,V,I) creation
			Qvi qviS = new Qvi(startLocation, listOfClocks.size(),
					listOfVariables);
			MDPGraph<String, MultiArc> g = new MDPGraph<String, MultiArc>();
			// 2) Addition of the initial (Q, V, I) to the graph (and to the
			// iteration stack)
			g.addVertex(qviS.toString());
			workingQueue.add(qviS);
			// 3) Start iterating over the (Q, V, I) in the working queue
			while (!workingQueue.isEmpty()) {
				Qvi current = workingQueue.remove(0);
				// FIRST RULE: STOP
				if (current.getTime() == max) {
					String stop = new Qvi("STOP", current.getClocks(),
							current.getVariables()).toString();
					// check if the stop node already exists (e.g. two nodes
					// with equal variables and clock can end to the same STOP!)
					if (!g.contains(stop.toString()))
						g.addVertex(stop.toString());
					// TODO rivedere gestione grafo
					g.addMultiArc(current.toString(),
							new MultiArc(stop.toString()));
					continue;
				}
				// SECOND RULE: URGENT
				if (isUrgentEnabled(current)) {
					functionalSemanticApplication(g, current, urEdges);
				} else {
					// THIRD RULE: TIME
					Qvi increment = new Qvi(current.getLocation(),
							current.getClocks(), current.getVariables());
					increment.makeTimePass(); // semantic application!!
					if (!g.contains(increment.toString())) {
						g.addVertex(increment.toString());
						workingQueue.add(increment);
					}
					// TODO rivedere gestione grafo
					g.addMultiArc(current.toString(),
							new MultiArc(increment.toString()));
					// FORTH RULE: NOT URGENT // TIME and NOT URGENT rules are
					// applied "at the same code level" because we build the
					// final graph as a BFS over the graph; since time and
					// functional edges coexist they are built together
					functionalSemanticApplication(g, current, edges);
				}
			}
			return g;
		} catch (Exception e) {
			System.err.println("Errore durante la creazione del MDP. "
					+ e.getMessage());
			e.printStackTrace();
			return null;
		}
	}

	private void functionalSemanticApplication(MDPGraph<String, MultiArc> g,
			Qvi current, HashMap<String, ArrayList<ArrayList<Edge>>> map) {
		ArrayList<ArrayList<Edge>> edgez = map.get(current.getLocation());
		if (edgez == null)
			return;
		// else...
		for (ArrayList<Edge> eU : edgez)
			if (isGuardSatified(eU.get(0), current)) {
				MultiArc m = new MultiArc(eU.size()); // multiarc creation
				for (Edge e : eU) {
					Qvi next = new Qvi(e.getLabel(), current.getClocks(),
							current.getVariables());
					// apply resetZ and assignmentZ of the edge
					Utility.ApplyResets(next.getClocks(), e.getResets());
					Utility.ApplyAssignments(e.getAssignments(), decs,
							next.getClocks(), next.getVariables());
					// check vertex...
					if (!g.contains(next.toString())) {
						g.addVertex(next.toString());
						workingQueue.add(next);
					}
					// ...finally add sub-edge to the multiarc
					m.addArc(next.toString(), e.getProbability());
				}
				// check multiarc addition to the graph!!!
				g.addMultiArc(current.toString(), m);
			}
	}

	private boolean isUrgentEnabled(Qvi current) {
		ArrayList<ArrayList<Edge>> uEdges = urEdges.get(current.getLocation());
		if (uEdges != null) {
			for (ArrayList<Edge> eU : uEdges)
				if (isGuardSatified(eU.get(0), current))
					return true;
		}
		return false;
	}

	private boolean isGuardSatified(Edge e, Qvi l) {
		if (e.getGuard() == null)
			return true;
		return e.getGuard()
				.evaluateGuard(decs, l.getClocks(), l.getVariables());
	}

	public void saveMDP(MDPGraph<String, MultiArc> g, String path) {
		BufferedWriter buffered = null;
		try {
			buffered = new BufferedWriter(new FileWriter(path));
			// HEADER START
			buffered.write("mdp");
			buffered.newLine();
			buffered.write("module EPDTA2PRISM\n");
			buffered.newLine();
			buffered.write("//--- Locations ---//");
			buffered.newLine();
			buffered.write("LOC: [0.." + g.getVertexCount() + "];");
			buffered.newLine();
			buffered.newLine();
			// HEADER CLOCKS DECLARATION
			buffered.write("//--- Clocks ---//");
			buffered.newLine();
			for (Declaration d : listOfClocks) {
				buffered.write(d.getVar().toLowerCase() + " : [0" + " .. "
						+ max + "] init 0; ");// + (int) d.getValue() + ";");
				buffered.newLine();
			}
			buffered.newLine();
			// HEADER VARIABLES DECLARATION
			buffered.write("//--- Variables ---//");
			buffered.newLine();
			for (Declaration d : listOfVariables) {
				if (d.getBool() == null)
					buffered.write(d.getVar().toLowerCase() + " : ["
							+ (int) d.getMin() + ".." + (max+1) + "] init "
							+ (int) d.getValue() + ";");
				else
					buffered.write(d.getVar().toLowerCase()
							+ " : bool init " + d.getBool().booleanValue() + ";"); 
				buffered.newLine();
			}
			buffered.newLine();
			buffered.write("//--- Transitions ---//");
			buffered.newLine();
			// BODY
			for (int i = 0; i < g.getVertexCount(); i++) {
				ArrayList<MultiArc> arcs = g.getArcs(i);
				String sourceLabel = g.Nodes.get(i);
				for (MultiArc arc : arcs) {
					buffered.write(getPTAString(sourceLabel,
							g.getVertexIndex(sourceLabel), arc, g));
					// TAIL
					buffered.write(";");
					buffered.newLine();
				}
			}
			buffered.newLine();
			buffered.write("endmodule");
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				buffered.close();
				buffered = null;
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
	}

	private String getPTAString(String sourceLabel, int sourceIndex,
			MultiArc arc, MDPGraph<String, MultiArc> g) {
		String locLabel = sourceLabel;
		String sourceQvi = getPTAState(sourceLabel, sourceIndex);
		String probLabels = "";
		//
		for (int j = 0; j < arc.arcs.length; j++) {
			String target = (String) (arc.arcs[j].second);
			locLabel += "_TO_" + target;
			probLabels += "+ "
					+ arc.arcs[j].first
					+ ":"
					+ getPTAState(target, g.getVertexIndex(target), sourceLabel);
		}
		return new String("[" + locLabel + "] " + sourceQvi + " -> "
				+ probLabels.substring(2));
	}

	private String getPTAState(String qvi, int index) {
		String dump = "LOC=" + index;
	//variable and clock non useful in Prism Model
		//	String[] clocks = qvi.split("__")[1].split("_");
	//	String[] vars = qvi.split("__")[2].split("_");
	/*	for (int i = 0; i < clocks.length; i++)
			dump += " & " + listOfClocks.get(i).getVar() + "=" + clocks[i];
		for (int i = 0; i < vars.length; i++)
			dump += " & "
					+ listOfVariables.get(i).getVar()
					+ "="
					+ (listOfVariables.get(i).isBool() ? vars[i].equals("0.0") ? "false"
							: "true"
							: vars[i]);
		*/return dump;
	}

	private String getPTAState(String qviD, int index, String qviS) {
		//variable and clock non useful in Prism Model
		//	String[] clocksS = qviS.split("__")[1].split("_");
	//	String[] varsS = qviS.split("__")[2].split("_");
	//	String[] clocksD = qviD.split("__")[1].split("_");
	//	String[] varsD = qviD.split("__")[2].split("_");
		String dump = "(LOC'=" + index + ")";
		/*for (int i = 0; i < clocksD.length; i++)
			if (clocksD[i].equalsIgnoreCase("0")
					&& !clocksS[i].equalsIgnoreCase("0"))
				dump += " & (" + listOfClocks.get(i).getVar() + "'=0)";
		for (int i = 0; i < varsD.length; i++)
			if (varsD[i].equals(varsS[i]))
				dump += " & ("
						+ listOfVariables.get(i).getVar()
						+ "'="
						+ (listOfVariables.get(i).isBool() ? varsD[i]
								.equals("0.0") ? "false" : "true" : varsD[i])
						+ ")";
	*/	return dump;
	}

}
